package algo;

import java.util.ArrayList;
import java.util.List;

public class Operator {

    /* 将节点i重新插入到j之后
         route: —— i ——...—— j ——
      => route: —— i-1 —— i+1 ——...—— j —— i —— j+1 ——
    */
    public static List<Integer> relocatedOperator(List<Integer> s, int i, int j) {
        List<Integer> ss = new ArrayList<>(s);
        int target = ss.get(i);
        ss.remove(i);
        ss.add(j, target);
        return ss;
    }

    /* 交换节点i和节点j
        route: —— i —— i+1 ... j-1 —— j ——
     => route: —— j —— i+1 ... j-1 —— i ——
    */
    public static List<Integer> exchangeOperator(List<Integer> s, int i, int j) {
        List<Integer> ss = new ArrayList<>(s);
        int temp = ss.get(i);
        ss.set(i, ss.get(j));
        ss.set(j, temp);
        return ss;
    }

    /* 将节点i到节点j之间元素反转
        route: —— i —— i+1 ... j-1 —— j ——
     => route: —— j —— j-1 ... i+1 —— i ——
    */
    public static List<Integer> twoOptOperator(List<Integer> s, int i, int j) {
        List<Integer> ss = new ArrayList<>(s);
        while (i < j) {
            int temp = ss.get(i);
            ss.set(i, ss.get(j));
            ss.set(j, temp);
            i++;
            j--;
        }
        return ss;
    }


    /* 将节点i和节点i+1插入到节点j和节点j+1之间
        route: ——i-1 —— i —— i+1 —— i+2 ... j —— j+1 ——
     => route: ——i-1 —— i+2 ... j —— i —— i+1 —— j+1 ——
    */
    public static List<Integer> orOptOperator(List<Integer> s, int i, int j) {
        List<Integer> ss = new ArrayList<>(s);
        if (j - i > 1) {
            int target1 = s.get(i);
            int target2 = s.get(i + 1);
            ss.remove(i);
            ss.add(j, target1);
            ss.remove(i);
            ss.add(j, target2);
        }
        return ss;
    }

    /* 将节点i到节点j之间的元素向右循环平移一位
        route: ——i-1 —— i —— i+1 —— j-1 —— j —— j+1 ——
     => route: ——i-1 —— j —— i —— i+1... j-1 —— j+1 ——
    */
    public static List<Integer> rightShiftOperator(List<Integer> s, int i, int j, int step) {
        List<Integer> ss = new ArrayList<>(s);
        int n = 0;
        while (n++ < step) {
            int end = ss.get(j);
            for (int k = i; k <= j; k++) {
                int temp = ss.get(k);
                ss.set(k, end);
                end = temp;
            }
        }
        return ss;
    }

    /* 将节点i到节点j之间的元素向左循环平移一位
        route: ——i-1 —— i —— i+1 —— j-1 —— j —— j+1 ——
     => route: ——i-1 —— j —— i —— i+1... j-1 —— j+1 ——
    */
    public static List<Integer> leftShiftOperator(List<Integer> s, int i, int j, int step) {
        List<Integer> ss = new ArrayList<>(s);
        int n = 0;
        while (n++ < step) {
            int start = ss.get(i);
            for (int k = j; k >= i; k--) {
                int temp = ss.get(k);
                ss.set(k, start);
                start = temp;
            }
        }
        return ss;
    }


}
